Shareware Super Platinum 8

home *** CD-ROM | disk | FTP | other *** search

/ Shareware Super Platinum 8 / Shareware Super Platinum 8.iso / mac / PROGTOOL / EVOLV201.ZIP;1 / EVOLVE.DOC < prev next >

Wrap

Text File | 1993-07-22 | 72.9 KB | 1,897 lines

EVOLVE! Copyright (C) Richard H. Smith, 1993 All Rights Reserved. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Why programmers need to use EVOLVE!. . . . . . . . . . . . . . . . . . . 3 What is source code maintenance? . . . . . . . . . . . . . . . . . . . . 3 What do programmers need to maintain source code? . . . . . . . . . 4 How EVOLVE! empowers programmers to maintain source code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 What is EVOLVE!'s relation to source code maintenance?. . . . . . . . . . . . . . . . . . . . . . . 5 How the report function transforms an outline into source code . . . . . . . . . . . . . . . . . . . . . . . 5 "<^>" . . . . . . . . . . . . . . . . . . . . . . . . . . 6 ":>". . . . . . . . . . . . . . . . . . . . . . . . . . . 6 How to explicitly define a structure . . . . . . . . . . . . . 6 Using ":>" and "<^>" together . . . . . . . . . . . . . . 8 How to use EVOLVE! . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 The user interface. . . . . . . . . . . . . . . . . . . . . . . . . 10 The menu bar and menus . . . . . . . . . . . . . . . . . . . . 10 Shortcuts. . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 The status line. . . . . . . . . . . . . . . . . . . . . . . . 11 Dialog boxes . . . . . . . . . . . . . . . . . . . . . . . . . 11 How to transform a source code file into an outline that explicitly defines the structure of the program. . . . . . . . 12 EVOLVE!'s Script Programming Language . . . . . . . . . . . . . . . 14 Command Reference. . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Menu structure. . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Description of commands . . . . . . . . . . . . . . . . . . . . . . 22 Menu items sorted by hotkey. . . . . . . . . . . . . . . . . . 33 License Agreement. . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Definition of Shareware . . . . . . . . . . . . . . . . . . . . . . 35 Disclaimer - Agreement. . . . . . . . . . . . . . . . . . . . . . . 35 Benefits of registering . . . . . . . . . . . . . . . . . . . . . . 36 How To Register . . . . . . . . . . . . . . . . . . . . . . . . . . 37 ASP Ombudsman Statement. . . . . . . . . . . . . . . . . . . . . . . . . 39 About the Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Introduction Mathematicians, and other technical people, sometimes talk about an abstract but simple concept they call a 'graph.' This kind of graph is independent of any particular visual representation. We can represent one graph an infinite number of ways. A graph is simply a set of nodes and edges. Each edge is a directed association of two nodes: an edge connects from one node to another node. Sometimes these graphs are called 'nets' or 'networks.' We can represent any information as a graph. In particular, a computer program's source code specifies a graph, and the compiler constructs that graph while parsing the source code. Graphs are fundamental to the way computers process information. Any information that has a structure is an example of a graph. EVOLVE! is a graph tool. It can edit graphs, generate an ASCII file that specifies the graph, and execute its own graph programming language. The report function of EVOLVE! can generate a graph specification in a wide range of grammars. Remember, every program is a graph specification. I use EVOLVE! to represent parts of itself as a graph, and generate its own source code in Borland Pascal. EVOLVE! facilitates developing and maintaining source code in any language. It will enable a programmer to design a program such that he can efficiently implement changes, much like a programmer can use constants and macros to improve the maintainability of source code. However, EVOLVE! presents the program in a more visual (rather than verbal) way that most people find more readable. EVOLVE! also enables users to dynamically inspect and modify a program's structure. The rest of this chapter will explain how EVOLVE! displays graphs. I need to use some trivial and meaningless example of a graph to clearly explain how to best display them on a computer screen. The example graph is 5 nodes {A,B,C,D,E} and 7 edges {AB,AC,AD,BE,CE,DE,EA}. The previous sentence represented the graph one way by just listing the nodes and edges. In figure 1 is another representation of the graph, where each node is represented by its name (e.g. a letter) and each edge is represented by a line. ⁄ƒƒ >B ƒƒƒø ≥ v ⁄ƒƒ >A ƒ >C ƒ >E ƒø ≥ ≥ ^ ≥ ≥ ¿ƒƒ >D ƒƒƒŸ ≥ ≥ ≥ ¿ƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒƒŸ Figure 1 An example graph You will usually see graphs represented by a drawing where each node is represented by an ellipse or polygon containing a node identifier and each edge is represented with a line. This is an effective format for representing a graph on paper. We can display even large graphs this way because large pieces of paper are inexpensive and easy to acquire. Imagine what would happen if we needed to show more text inside of each node. Or what if we had hundreds of nodes instead of five? We would need a lot of area to show a representation of this kind that was readable. This works well on paper, because you can get big pieces of paper. It does not work as well on a computer display, because they are usually only about a half page big. Some would argue that by using a scrollable window, a computer can display a large graph one small rectangle at a time. Personally, I find it difficult to take in a large graph when I can only see a small part of it at once. To clearly display large graphs on a computer screen, we need a representation that frugally uses space. The representation shown in the figure above has a lot of unused spaced that is aesthetically pleasing but communicates little information. The representation I prefer to use is that of a text outline. Below is our example graph represented as a text outline A 1. B 1. E 1. A 2. C 1. E 3. D 1. E With this format, the node 'A' is listed as a child of 'E' only once because listing it under every appearance of 'E' would be redundant. Note that we have a lot of room to the right of each node to display a full line of text. The text outline format above has one problem: how can we know that the 'E's and 'A's are the same node, or distinct nodes with identical names? One solution some graph representations use is to insist that each node have a unique name. EVOLVE! does not implement this solution. Instead, EVOLVE! displays a unique identifying number for each node that appears more than once. Below is how EVOLVE! could display this example graph. A {123456789:3} 1. B 1. E {123456780:1} 1. A {123456789:3} 2. C 1. E {123456780:1} 3. D 1. E {123456780:1} The curly brackets contain two numbers separated by a colon. The first number is a unique identifier. The second number is the number of edges that originate from that node. The edge from 'E' to 'A' is only represented once, but every image of 'E' indicates that there is one edge originating from it with the ':1}'. EVOLVE! is a graph tool that represents graphs as text outlines. EVOLVE! is also a source code maintenance tool because source code is a graph representation, and EVOLVE! has capabilities for transforming graphs between the source code representation and the text outline representation. Chapter 2 explains why programmers need to use EVOLVE!. Chapter 3 explains how to use EVOLVE!. Chapter 4 is a reference section for EVOLVE!. Why programmers need to use EVOLVE! Programmers need to use EVOLVE! for two reasons. First, proper use of EVOLVE! will minimize the keystrokes and decisions required to make source code changes. Second, programmers can use EVOLVE! to clarify their understanding of the consequences of source code changes. This chapter provides the information a user needs to understand what EVOLVE! is and what requirements it fulfills. This chapter's first section is a definition of source code maintenance. The second section describes the capabilities a programmer needs to maintain source code. The third section describes the tools, other than EVOLVE!, available for facilitating source code maintenance. The fourth section explains the source code maintenance capabilities that only EVOLVE! provides. What is source code maintenance? Source code maintenance is closely related to, but not equivalent to, software maintenance. Richard E. Fairley defines in his book "Software Engineering" software maintenance as "the software engineering activities that occur following delivery of a software product to a customer." This could include making changes to the software that do not involve changing the source code. You could produce a new version of an executable program by simply using a different compiler. Also, some instances of source code maintenance are not software maintenance. For example, a programmer may change a comment that was in error. If the comment does not affect any deliverables to the client, this modification is source code maintenance but not software maintenance. However, to the programmer who writes source code, software maintenance usually means changing the source code. The problem with the term "source code maintenance" is that it is not maintenance in the traditional sense. Traditionally, maintenance means restoring something that is worn out. Software does not wear out. The American Heritage Dictionary defines maintenance as "The action of continuing, carrying on, preserving, or retaining something." This does not describe what I think of as source code maintenance, unless the thing that source code maintenance continues, preserves, and maintains is the customer's satisfaction. Whether the software has been delivered to the customer makes no difference to the technical challenge of changing the source in an appropriate manner. Therefore, I define source code maintenance as the process of evolving software by implementing appropriate incremental changes. This process of evolving source code may occur during the development phase. Since we know that software does not wear out, we should consider why programmers need to change source code. There are three types of reasons programmers change source code. First, programmers need to correct problems. Second, the requirements for the program may change. Third, the development strategy may be based on incrementally evolving the program. The point here is that programmers make incremental changes to source code in software development as well as software maintenance. What do programmers need to maintain source code? Programmers need the following abilities to facilitate the safe and correct maintenance of source code. 1. The capability to modify the source code with a minimum of keystrokes and decisions. This reduces the probability a programmer will introduce new errors when he makes a modification. For example, programmers use named constants so that they can redefine the constant and re-compile and the compiler will implement the new value everywhere that constant is used. 2. The capability to encapsulate areas of the source code to avoid unintended side effects. 3. The ability to inspect the code and data structures to see the consequences of changes they are considering. How EVOLVE! empowers programmers to maintain source code EVOLVE! lets users program down to the lowest level of detail with a structure editor. It enables users to change and dynamically inspect a program's structure. When a programmer uses EVOLVE! to explicitly define the programs structure, she has at her disposal hypertext like links she can use to inspect the source code. This section answers the following questions: 1. What is EVOLVE!'s relation to source code maintenance? 2. How does the report function transform an outline into source code? 3. How can a programmer use EVOLVE! to explicitly represent the structure of a program as an outline? What is EVOLVE!'s relation to source code maintenance? EVOLVE! is in one way the complement of source code. Source code is always a sequence of symbols that define a structure. The structure defined by source code includes data structures, machine instructions, compiler directives, and comments to the reader of the source code. EVOLVE! is a structure editor that produces source code. It enables you to edit the structure as a hierarchy (a.k.a. outline), and produce source code from that hierarchy. Although EVOLVE! displays the program as an outline while a user edits it, he can press a key to instantly view the program as source code. When programmers use a text editor to create and modify a source code file, they use the syntax of the language and the identifiers they create to specify a structure that the compiler will understand and process into machine language. When a programmer uses EVOLVE!, he explicitly defines a structure (visually represented on the screen as an outline) that the EVOLVE! program processes to produce a text file of source code that specifies the explicitly defined structure. If the programmer creates a structure with EVOLVE!, he can use this structure to perform the following source code maintenance functions: 1. Efficiently implement changes without introducing new errors. 2. Dynamically inspect the structure of the code to evaluate the consequences of possible modifications. How the report function transforms an outline into source code The report command under the files menu will generate source code from an outline by processing two special strings. The first string is "<^>" and the second string is ":>". Programmers use the ":>" string to define the syntactic structure and the "<^>" string to define part of the semantic structure. "<^>" When a user chooses to produce a report, EVOLVE! processes the "<^>" string first by replacing each one with the text from a subsidiary line in the outline. Below is an example of how the report function processes "<^>": The <^> is <^>. car green The end. The outline above would produce the following report: The car is green. The end. Notice that EVOLVE! accounts for how many subsidiary lines were used to replace "<^>", and processes the rest. ":>" The ":>" string is used to define delimiters. Many programming languages will use a comma or semicolon in between items in a list, and a special string to mark the end like '}', ')', or 'end'. You can use ":>" twice in one line: first to specify the in between delimiter and second occurrence of ":>" to define the ending delimiter. Below is an example: MyFunc(:>,:>) aaa bbb ccc The outline above would produce the following report: MyFunc( aaa, bbb, ccc) How to explicitly define a structure Users will want to create an outline where an identifier appears in more than one place. The best way to do this is to place each identifier on a separate line and use '<^>' to place the identifier in the "parent" line of the outline. The reason users should place each identifier on a separate line is that they can reference a line. Users should not simply retype or copy identifiers because that creates new instances of the identifier. The new line created by a copy is distinct from the originals. The "mark" and "reference" commands enable users to create another appearance of a line, where both the original appearance and the new appearance refer to the same instance of the line. When a user makes a change to a line that appears in more than one place (because it is referenced) the change is implemented at all locations. A user can create a new appearance of a line by: 1. If any lines are already marked, press [Alt-U] to unmark all lines. 2. "mark" the line(s). 3. move the cursor to the parent of the new appearance(s). 4. press [Alt-=] to "reference" the marked line(s). There are three ways to mark a line: 1. Users can mark an unmarked line and unmark a marked line by double clicking the left mouse button. 2. Users can mark the next (or previous) line with a specified substring. The command for this is named "Mark if found" and its hot key is [Ctrl-F6]. 3. Users can position the cursor on a line and press [Alt-Space] to mark an unmarked line and unmark a marked line. Appearances of a referenced line identify themselves by displaying a unique number, followed by the number of children they have. It looks like this: a referenced line {1234567890:5} If she references an identifier where it makes sense, she will benefit in the following ways: 1. She can use the "Go to parent" command [F7] to see a list of everywhere that identifier is used in the source code. 2. Any change he makes to one appearance of an identifier is implemented at all appearances of that identifier. Using ":>" and "<^>" together Below is an example Pascal program that reads two numbers and prints out their product: Program MultiplyTwo; {This program reads in two numbers and prints the product} Var FirstNumber : Integer {The first number}; SecondNumber : Integer {The second number}; MyResult : Integer {The answer}; Function MultiplyTwoNumbers(OneNumber : Integer;AnotherNumber : Integer) : Integer; begin MultiplyTwoNumbers := OneNumber * AnotherNumber; end; begin readln( FirstNumber, SecondNumber); MyResult := MultiplyTwoNumbers( FirstNumber, SecondNumber); writeln( 'The first: ', FirstNumber, ' The Second: ', SecondNumber, ' The Product: ', MyResult); end. EVOLVE! will generate this program source code from the following outline: Program MultiplyTwo;:>;:>. {<^>} This program reads in two numbers and prints the product Var:>; <^> : <^> {The first number} FirstNumber {18269:0} Integer {18274:0} <^> : <^> {The second number} SecondNumber {18287:0} Integer {18274:0} <^> : <^> {The answer} MyResult {18302:0} Integer {18274:0} Function <^>(<^>;<^>) : <^>; MultiplyTwoNumbers {18318:0} <^> : <^> OneNumber {18331:0} Integer {18274:0} <^> : <^> AnotherNumber {18346:0} Integer {18274:0} Integer {18274:0} begin:>;:>end <^> := :> * MultiplyTwoNumbers {18318:0} OneNumber {18331:0} AnotherNumber {18346:0} begin:>;:>end readln(:>,:>) FirstNumber {18269:0} SecondNumber {18287:0} <^> := <^>(:>,:>) MyResult {18302:0} MultiplyTwoNumbers {18318:0} FirstNumber {18269:0} SecondNumber {18287:0} writeln(:>,:>) 'The first: ' FirstNumber {18269:0} ' The Second: ' SecondNumber {18287:0} ' The Product: ' MyResult {18302:0} The above outline explicitly defines the structure of the program. When a programmer, using EVOLVE!, has an outline with an explicitly defined structure he can efficiently manage the source code changes. He can also use the outline to dynamically inspect the program's structure to evaluate the consequences of possible changes. The reader should not let the size of the above outline mislead him to think that it takes more keystrokes to build the outline than to type the source code. The "Marking" commands let users reference an identifier with fewer keystrokes than it takes to type it. To summarize this section, EVOLVE! is a source code structure editor. The user can "mark" and "reference" identifiers to explicitly define part of the semantic structure. The user can define the rest of the semantic structure with the "<^>" character. When the user invokes the "report" function, EVOLVE! replaces each "<^>" with the text of a child in the outline. The user can define some of the syntactic structure with the ":>" string. Together, the syntactic and semantic structures comprise the structure of the program's source code. EVOLVE! enables users to explore and edit a program's structure explicitly and dynamically. How to use EVOLVE! This chapter explains how to use EVOLVE!. The first section describes general features of the user interface. The second section gives an example of how to transform a source code file into an outline. The third section explains the macro-programming language. The user interface EVOLVE!'s user interface has the general features common to most modern software programs. These general features are pull down menus, shortcuts, windows, status line, and dialog boxes. The menu bar and menus The menu bar is your primary access to all the menu commands. You'll see a highlighted menu title when the menu bar is active; this is the currently selected menu. Here is how you choose menu commands using just the keyboard: 1. Press [F10]. This makes the menu bar active. 2. Use the arrow keys to select a sub-menu to display. Then press [Enter]. As a shortcut to this step, a user can just press the highlighted letter of the sub-menu title. For example, from the menu bar, press [F] to quickly display the file menu. From anywhere, press [Alt] and the highlighted letter to display the menu you want. 3. Use the arrow keys again to select the command desired. Then press [Enter]. Again, as a shortcut, users can just press the highlighted letter of a command to choose it once the menu is displayed. At this point, EVOLVE! either carries out the command, displays a dialog box, or displays another menu. Shortcuts A user can access many items in the menus with key combinations called shortcuts. These key combinations are shown to the right of the menu item in the menu boxes, and to the left of the command in the status line. On page 33 there begins a list of menu items and their associated shortcuts. This list is sorted by shortcut key. Windows Windows in EVOLVE! have the following: 1. A title at the center of the top border. The title is the name of the file associated with the window. 2. A window number. You can quickly select a window by pressing [Alt] and the number of the window. 3. Horizontal and vertical scroll bars to show you the location of your view into a virtual screen. 4. A position indicator at the left of the lower window border that displays the row and column of the cursor. 5. A 'splat' character that appears to the left of the position indicator when you have changed the program since the last save. The status line The status line appears at the bottom of the screen. It reminds you of basic keystrokes and shortcuts applicable at that moment in the active window. Dialog boxes When a user is making settings in dialog boxes, they work with four basic types of on-screen controls: radio buttons, action buttons, input boxes, and list boxes. Users can use [Tab] to select the next control in the dialog box and [Shift-Tab] to select the previous control in the dialog. Most controls have labels with one letter highlighted. Users can select a control object by pressing [Alt] and the highlighted letter. Users can close the dialog box by either selecting the "OK" button to accept the data in the box and press [Enter], or cancel any action by the box by pressing [Escape] or selecting a "Cancel" button and pressing return. Radio buttons work like the buttons on a radio; they represent mutually exclusive choices. Use [Tab] or [Shift-Tab] to select the group of radio buttons. Then select the item you want with the up and down arrow keys and press [Space] to toggle that item. Toggling a radio button untoggles the previously toggled button. Input boxes are fields where text is entered and edited. Most basic text editing keys work in the text box. If an input box has a down-arrow icon to its right, there is a history list associated with the input box. Press [Down Arrow] to view the history list and enter to select an item from the list. This list will display any text you typed into the box the last few times you used it. Users can edit any item in the history list. Press [Escape] to exit the history list without making a selection. A final component of many dialog boxes is a list box. A list box lets you scroll through and select from variable-length lists without leaving a dialog box. If a blinking cursor appears in the list box and the user knows what he is looking for, he can type the first letters of the text and the listbox will search for it. He can move through the list with [Up Arrow] and [Down Arrow]. How to transform a source code file into an outline that explicitly defines the structure of the program This section is an example of how to transform the source code of a program into an outline in EVOLVE!. 1. Press return at the opening screen to get rid of it. 2. Press [Ctrl-F8] to import an ASCII file. 3. Select the name of a file already on the disk. 4. Press [F9] to save the outline as a file with a different extension, preferably ".MNT". 5. Press [Alt-X] to exit. A programmer should be able to produce source code from this outline now by pressing [Ctrl-F7], which invokes the report to file function. The outline as it stands now does not explicitly define the structure of the program. You can transform the outline into an explicit representation of the source code structure through a range of strategies. This range of strategies is bounded by two extremes: all at once, or as needed. This section first discusses defining the semantic structure explicitly, and then defining the syntactic structure explicitly. An explicitly defined semantic structure will enable users to gain the full utility of the "Go to parent" command, [F7]. This command will let you see all the lines of source code that use a given identifier. The all at once strategy, for the semantic structure, is to start at the top of the outline and perform the "Search,Extract,Mark/Reference" command for each identifier. This command is found in the "Marking" menu. The step above specifies a lot of work if the user chooses to transform the outline all at once. However, there is another strategy that may be more practical for some cases. A programmer can transform the outline a little at a time as he needs it. When he has to make a source code modification, he performs the steps specified above, but only for the identifiers relevant to the source code modification. An explicitly defined syntactic structure is useful, but not as useful as an explicitly defined semantic structure. The syntactic structure is defined with the ":>" string. Languages like C and Pascal use special syntax to delimit lists of things. In Pascal, each invocation of a function that takes parameters must include a list of parameters to pass to that function. This list of parameters in the invocation begins with a left parenthesis, ends with a right parenthesis, and separates each item in the list with a comma. I do not recommend a programmer explicitly define the syntactic structure of a function call with ":>" if it is fully contained in one line of text. However, there are some cases where function calls are nested to form a hierarchy. Some user interface tools encourage programmers to define menu structures this ways. The syntax can get difficult to manage. A programmer can use the ":>" string most efficiently for that case. I suggest programmers start at the deepest levels of the outline and look for places they can extract the syntax to the parent line. In short, the way to transform a source code file is to import it as an ASCII file, then use the 'Search, Extract, Mark/Reference' command on identifiers. EVOLVE!'s Script Programming Language Sometimes a users finds herself performing a similar sequence of commands through the use of menus or hotkeys. Users can sometimes automate these sequences of commands by using a script program. These scripts are outlines themselves, where each line is either a script command, an expression, or a data item. You can execute any part of an outline as a script by placing the cursor on the first line of the script and pressing [Alt-F10]. Most of the menu items that operate within the context of just one window have an equivalent script command. For example, the 'Move cursor' menu has an item 'to first line' that performs the same function as the script command 'cmFirstLine'. Another example is the 'Go to line number' menu item which is equivalent to the script command 'cmGoToLine'. This script command looks for the line number in the first child of its line. All the script commands that are similar to menu items are outline script commands. This user's guide explains each outline script command with its corresponding menu item in the user interface reference. EVOLVE! augments the power of the outline script commands with data flow script commands and control flow script commands. Data flow script commands evaluate expressions and move the result to other lines. Control flow commands control the sequence in which EVOLVE! executes the script commands. The data flow commands are: cmMoveOutlineData cmMoveOutlineNumber cmMoveProgramData cmMoveProgramNumber cmMoveProgram2Outline The cmMoveOutlineData and cmMoveOutlineNumber act on the outline with out affecting the script as it is currently executing. When you execute part of an outline as a script, EVOLVE! first makes a copy of the script so any changes the script makes to the outline will not accidentally interfere with the script. This copy is executed as the script program and deleted at the end of the script's execution. At the moment of replication, the script's current instruction corresponds to the outline's current line. However, after replication the script and the outline are separate and independent. Thus, we can write script's that safely alter the outline without accidentally interfering with the script's execution. These 'cmMoveOutline...' commands act on the children of the current line in the outline. They take information from the first child and pass the information to all other children of the current line. Likewise, the cmMoveProgramNumber and cmMoveProgramData affect the script that is currently executing, and will not affect the outline. These commands act on the children of the current instruction in the script. They both transfer data from the first child of the current instruction to all other children of the current instruction. The cmMoveProgram2Outline command transfers data from the current instruction to the outline's current line. The commands that end with the word 'Number' evaluate the first child as a real number expression. A real number expression is simply a real number or an expression that produces a real number. Below is a list of expression that produce a real number. + Sum all children of the this script line - Negate and sum all children of this script line / divide the first child of this script line by the product of all other children * multiply all children of this script line ? the position of the outline's current line among its siblings, less one. If the outline's current line is the first child of its parent, it returns 0. If the outline's current line is the second child of its parent, it returns 1. Etc... # the number of children under the outline's current line <=> compares the first two children of this script line as numeric expressions. Result Meaning ============================================= 1 First child is less than second 2 First and second child are equal 3 Second child is less than the first child 4 There is an error == This test to see if all the children of the outline's current line are references of the same line. If two lines are references of the same line they will have the same two numbers inside of curly brackets to the right of their text. Result Meaning ==================== 1 all reference the same line 2 not all the same 3 Error = test to see if the text in each child of this script line the are all equal Result Meaning ============================================= 1 First child is less than second 2 First and second child are equal 3 Second child is less than the first child 4 There is an error The commands that end with the word 'data' process the first child as a text expression. A text expression is simply a line of text or an expression that produces a line of text. Each occurrence of the string <^> is replaced with the text produced by a child. The first occurrence is replaced by the text produced by the first child. The second occurrence is replaced by the text produced from the second child, and so forth. Example 1 of cmMoveOultineData: Before execution cmMoveOutlineData This is the first line, place cursor here 1. Hello world. 2. After execution cmMoveOutlineData This is the first line, place cursor here 1. Hello world. 2. Hello world. Example 2 of cmMoveOutlineData with a text expression Before execution cmMoveOutlineData 1. <^> <^>. 1. Hello 2. world 2. After execution cmMoveOutlineData 1. <^> <^>. 1. Hello 2. world 2. Hello world. Example 3 cmMoveOutlineNumber Before execution cmMoveOutlineNumber 1. 5.5 2. After execution cmMoveOutlineNumber 1. 5.5 2. 5.5000000000E+00 Example 4 cmMoveOutlineNumber with an expression Before execution cmMoveOutlineNumber 1. + 1. 2.3 2. 3.2 2. After execution cmMoveOutlineNumber 1. + 1. 2.3 2. 3.2 2. 5.5000000000E+00 The cmMoveProgramData and cmMoveProgramNumber commands are similar but they do not affect the outline. These commands perform similar functions on the script program. The command cmMoveProgram2Outline will evaluate the first child of the current instruction as a text expression, and set the current line in the outline to that result. The control flow commands are: DoAll, DoOne, Loop, and Pop. DoAll will execute each child of the current instruction as a command. DoOne will evaluate the first child of the current instruction as an expression that produces a number. The result of the first child of the current instruction indicates which child, if any, will succeed it as the current instruction. The Nth child of DoOne is executed if N is the lowest upper bound of the numeric result from the first child. If the first child is the value 5 then the sixth child will execute next. After the sixth child executes, the next instruction will be the sibling following the DoOne command. In other words, the script will not execute more than one child of a DoOne instruction. Loop, like DoAll, will execute each child as a command. In addition, Loop will repeat itself by starting with the first child again after the last child is executed. The only way to stop the Loop cycle is with a Pop command. Pop will exit out of the current Loop. Pop will also exit out of a DoAll. When Loop's and DoAll's are nested, Pop will exit out of the last DoAll or Loop that the EVOLVE! script is still processing. The user can execute any part of an outline as a script by placing the cursor on the first line of the script and pressing [Alt-F10]. Each line in the script can be one command or data item. Any text to the right of a script command in a line is ignored, so we may use this space to place comments. A script command can be a control flow command, data flow command, or an outline command. The control flow commands direct the order in which script instructions take their turn as the current instruction. Data Flow commands move information through the outline and the script. The outline script commands act on the outline, and they correspond to a similar menu command. The script outline commands are a subset of the commands available through the EVOLVE! menu. The reference section documents each script outline command with its corresponding menu item. The following examples use the data flow, control flow and outline commands listed in this chapter. Before execution Example 7 `-DoAll add lines with numbers in them `-Loop through this |-DoOne | |-<=> | | |-0 count {48173600:0} | | `-5 | |-cmAddSibling makes a new blank line below this script | `-Pop out of this loop |-cmMoveProgramNumber This increments the loop counter | |-+ | | |-1 | | `-0 count {48173600:0} | `-0 count {48173600:0} `-cmProgram2Outline sends the value of count to new line `-0 count {48173600:0} After execution Example 7 |-DoAll add lines with numbers in them | `-Loop through this | |-DoOne | | |-<=> | | | |-0 count {48173600:0} | | | `-5 | | |-cmAddSibling makes a new blank line below this script | | `-Pop out of this loop | |-cmMoveProgramNumber This increments the loop counter | | |-+ | | | |-1 | | | `-0 count {48173600:0} | | `-0 count {48173600:0} | `-cmProgram2Outline sends the value of count to new line | `-0 count {48173600:0} |- 1.0000000000E+00 |- 2.0000000000E+00 |- 3.0000000000E+00 |- 4.0000000000E+00 `- 5.0000000000E+00 Command Reference A user can select any menu item he sees displayed at the top of the screen by holding down [Alt] key and the highlighted letter in the menu choice. If the menu is active, don't use [Alt], just use the highlighted letter. A user can activate the main menu by pressing [F10]. Also, he can press [Alt-F] or [Alt-R] or [Alt-M] or [Alt-E] or [Alt-W] or [Alt-A] to activate the main menu and the associated submenu. Many commands lead to dialog boxes. When these dialog buttons come up, they usually have the "cancel" option highlighted. If a user presses return, the box will go away and no changes will be made. If a user wants to do something in a dialog box, he can press [Tab] to move to the first object in the box. Likewise, [Shift-Tab] will move him to the previous object in the box. Menu structure The Menu Structure is: Menus [F10] I. File [Alt-F] A. Open [F3] B. Save [F2] C. Save As [F9] D. Change Directory [Shift-F9] E. Print [Ctrl-PrtScr] F. Print to File [Shift-F7] G. Report to File [Ctrl-F7] H. Import ASCII File [Ctrl-F8] I. Dos Shell I. Exit [Alt-X] II. Relocate Items [Alt-R] A. Line to clipboard [Shift-F1] B. Tree to clipboard [Ctrl-F1] C. Line from clipboard [Shift-F2] D. Tree from clipboard [Ctrl-F2] E. Marked Lines to under current [Shift-F3] F. Tree left a level [Ctrl-Left] G. Tree right a level [Ctrl-Right] H. Tree up [Ctrl-PgUp] I. Tree Down [Ctrl-PgDn] J. Sort 1. Ascending Grey-Plus 2. Descending Grey-Minus III. Move Cursor [Alt-M] A. to child [F4] B. to parent [F7] C. to sibling [F8] D. to marked [Alt-J] E. to any report line [Ctrl-F9] F. to descendant report line [Alt-F9] G. Search [Alt-S] H. Go to line # [Alt-G] I. First line [Ctrl-Home] J. Last line [Ctrl-End] K. Up a line [Up] L. Down a line [Down] M. Up a screen [PgUp] N. Down a screen [PgDn] N. to basis of current IV. Edit [Alt-E] A. Add a line 1. as a child of current [Ctrl-Enter] 2. as a sibling of current [Enter] 3. as a parent of current [Ctrl-F3] 4. as the first line B. Copy 1. Current line to clipboard [Alt-C] 2. Current tree to clipboard [Alt-K] 3. Marked lines to clipboard [Shift-F4] 4. Marked trees to clipboard [Ctrl-F4] C. Delete 1. Current line [Alt-D] 2. Current tree [Shift-Delete] D. Display 1. Hide children [Alt-H] 2. Show children of current [Alt-F8] 3. Show all children 3. Select display style E. Undo [Esc] V. Marking [Alt-A] A. Mark/Unmark a line [Alt-Space] B. Reference marked lines [Alt-=] C. Unmark all lines [Alt-U] D. Mark if found [Ctrl-F6] E. Search,Extract,Mark/Reference VI. Window [Alt-W] A. Next [F6] B. Previous [Shift-F6] C. Close window [Alt-F3] D. Tile windows [Alt-Z] E. Cascade windows [Shift-F8] F. Size/Move window [Ctrl-F5] G. Zoom [F5] H. Open Clipboard In addition, a single click of the left mouse button sets the cursor to a line, and a double click marks or unmarks a line. Description of commands Edit|Add a line|As a child of current Ctrl-Enter Creates a new line and inserts it as a child of the current line. Script: cmAddLine Edit|Add a line|As a sibling of current Enter Creates a new line and inserts it as a sibling of the current line. Script: cmAddSibling Edit|Add a line|as a parent of current Ctrl-F3 Creates a new line and inserts it as the parent of the current line. Script: cmAddBranch Edit|Add a line|as the first line Creates a new root line and inserts the old root into the new root. Script: cmAddRoot Edit|Copy|Current line to clipboard Alt-C Copies a line from the current window to the clip board. The children of the line (if any) are not copied. If the clip board is not open yet, EVOLVE! will open it. Edit|Copy|Marked lines to clipboard Shift-F4 Copy marked lines to the current line of the clipboard. This command will open the clipboard if necessary. Edit|Copy|Marked trees to clipboard Ctrl-F4 Copy marked trees to the current line of the clipboard. This command will open the clipboard if necessary. Edit|Copy|Tree to clipboard Alt-K Copies a subtree from the current window to the clip board. This command will open the clipboard if necessary. Edit|Delete|Current line Alt-D Deletes the current line from the current window. If the line has children, the line's parent will adopt them. Script: cmDelLine Edit|Delete|Current tree Shift-Delete Erases the current subtree in the current window. Script: cmDelTree Edit|Display|Hide children Alt-H Hides the children of the current line. Script: cmHideKids Edit|Display|Select display style EVOLVE! provides four styles for outlines: 1. A conventional outlining style. 2. A numbered list style. 3. Blanks only. 4. Line drawing characters. Below are examples of the four styles. Outline Title I. First Main topic A. First Subtopic 1. First sub-sub-topic i) Minor topic a) Minor point 1) Sub-minor point 2) Another sub minor point b) Another minor point ii) Another minor topic 2. Second sub-sub-topic B. Second subtopic II. Second main topic Outline Title 1. First Main topic 1. First Subtopic 1. First sub-sub-topic 1. Minor topic 1. Minor point 1. Sub-minor point 2. Another sub minor point 2. Another minor point 2. Another minor topic 2. Second sub-sub-topic 2. Second subtopic 2. Second main topic Outline Title First Main topic First Subtopic First sub-sub-topic Minor topic Minor point Sub-minor point Another sub minor point Another minor point Another minor topic Second sub-sub-topic Second subtopic Second main topic Outline Title |-First Main topic | |-First Subtopic | | |-First sub-sub-topic | | | |-Minor topic | | | | |-Minor point | | | | | |-Sub-minor point | | | | | `-Another sub minor point | | | | `-Another minor point | | | `-Another minor topic | | `-Second sub-sub-topic | `-Second subtopic `-Second main topic Edit|Display|Show all children Shows every line of the outline. Script: cmShowAllKids Edit|Display|Show children of current Alt-F8 Shows the children of the current line. Script: cmShowKids Edit|Undo Esc Undoes the changes to the current line. This only has an effect if the cursor has not moved off the line since the changes were made. Script: cmUndo File|Change Directory Shift-F9 File≥Change Dir brings up the Change Directory dialog box, in which you can change the current directory. File|Dos Shell Shells to DOS. This allows you access to DOS without closing EVOLVE!. Script: cmExec The script version of this command is slightly different. It does not shell to DOS, rather it executes each child line as a DOS command. When EVOLVE! executes this script command, it takes the first word in each line and looks for an executable file of that name. If the first token is not the name of an executable file, EVOLVE! attempts to execute the line through the command processor specified by the COMSPEC environment variable. This command processor is usually 'command.com' which will process commands like 'Dir.' File|Exit Alt-X The Exit command terminates this program. File|Import ASCII File Ctrl-F8 Reads an ASCII file and transforms it into an outline. This is the complement of Report. Script: cmTroper In the script, the first child is taken as the name of the file to import. File|Open F3 The Open command displays the Open a File dialog box. In this dialog box you select the data file you want to use. The "Open a File" dialog box contains: ˛ an input box with a history list ˛ a list box to browse the directory ˛ the standard Cancel button ˛ Open action button ˛ an information panel that describes the selected file Script: cmFOpen In the script, the first child is taken as the name of the file to open. File|Print Ctrl-PrtScr Prints the outline in the current window. Script: cmPrint File|Print to File Shift-F7 Prints the outline descendant from the current line to a file. Script: cmPrint2F In the script, EVOLVE! takes the first child to be the name of the file to print to. File|Report to File Ctrl-F7 Prints a report to a file. The report is produced by processing the outline. The blank display style used so no line drawing characters, roman numerals, or numbering will be put into the report file by EVOLVE!. EVOLVE! will look for the ":>" to define text to print after its children. The first ":>" starts the string that EVOLVE! appends to the end of each terminal descendant except the last terminal descendant. The second ":>" string defines the string that EVOLVE! appends to the end of the last terminal descendant. A terminal descendant is the last child itself if there are no children of the last child. Otherwise, the terminal descendant is the terminal descendant of the last child. Script: cmReport File|Save F2 Saves an outline (the current line and all descendant lines) in the current window to a data file. File|Save As F9 Enables you to save an outline to a file name other than the one shown as the title of the window. The outline saved will be the current line and all descendants. Script: cmFSaveAs In the script, EVOLVE! takes the first child to be the name of the file to save the outline to. Marking|Mark if found Ctrl-F6 Marks the first line found that contains the substring you specify. Marking|Mark/Unmark current line Alt-Space If the current line is unmarked, this command marks it. If the current line is marked, this command unmarks it. Marked lines form a set of lines that the user may reference at other locations, or jump to with the 'Move cursor|Go to marked' menu item. Script: cmMark Marking|Reference marked lines Alt-= References all marked lines. Script: cmReference Marking|Search,Extract,Mark/Reference This command performs the following steps: 1. Unmark all marks. 2. Searches for the specified text and conditions. 3. Asks the user to confirm marking/referencing the text found. 4. Extracts the text from the line and replaces it with "<^>". 5. If nothing is marked, the extracted text is inserted as a child and the new child is referenced. The new child has the correct position to be processed by the "<^>" during a report. 6. If something has been marked, the mark is referenced. The referenced child is positioned such that it will be processed by the "<^>" during a report. The text produced by a report after this process is identical to the text produced before this process. Marking|Unmark all lines Alt-U Unmarks all marked lines. Script: cmUnMarkAll Move Cursor|Down a line Down Select the line below as the current one. Script: cmMoveDown Move Cursor|Down a screen PgDn Moves the visible portion of the window down the height of the window. The command moves the cursor also to keep it visible in the window. Move Cursor|First line Ctrl-Home Goes to the first line in the outline. Script: cmFirstLine Move Cursor|Go to line # Alt-G Moves to the selected line number. Script: cmGoToLine In the script, EVOLVE! looks for the line number at the beginning text of the first child. Move Cursor|Last line Ctrl-End Goes to the last line in the outline. Script: cmLastLine Move Cursor|Search Alt-S Search will open a dialog box where you can enter text. EVOLVE! will then search in the direction you specify for the next occurrence of that text and make that occurrence the current line. Move Cursor|Up a line Up Selects the line above as the current line. Script: cmMoveUp Move Cursor|Up a screen PgUp This command moves the visible portion of the window up the height of the window. The command moves the cursor also to keep it visible in the window. Move Cursor|to basis of current Goes to the Basis. When a line is referenced, only one instance shows the children explicitly. The instance that shows the children is the basis. Script: cmGoToBasis Move Cursor|to child F4 Select one of the current line's children as the current line. Script: cmGoToKid In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which of the current line's children will become the next current line. If the number is 0 then the first child will become the current line. In general, if the number is N then the N+1 child will become the current line. Move Cursor|to marked Alt-J Selects one of the Marked lines as the current line. This is a good way to see the marked lines. The lines are shown in a scrollable menu. Each line begins with the line number that the text appears at. The text that follows the line number has the <^> characters replaced with the appropriate text. Script: cmGoToMark In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which of the marked line's will become the next current line. If the number is 0 then the first marked line will become the current line. In general, if the number is N then the N+1 marked line will become the current line. Move Cursor|to parent F7 Selects one of the current line's parents as the current line. This is a good way to see the parent lines. The lines are shown in a scrollable menu. Each line begins with the line number that the text appears at. The text that follows the line number has the <^> characters replaced with the appropriate text. Script: cmGoToParent In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which of the current line's parents will become the next current line. Each referenced line will have multiple appearances and one parent per appearance. If the number is 0 then the first parent will become the current line. In general, if the number is N then the N+1 parent will become the current line. Move Cursor|to report line Ctrl-F9 Displays the report text and enables you to move to the outline entry that corresponds to the reported line. This is a good way to see the source code as reported. The lines are shown in a scrollable menu. Script: cmGoToRepLine In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which report line will become the next current line. Move Cursor|to descendant report line Alt-F9 Displays the report text and enables you to move to the outline entry that corresponds to the reported line descendant from the current line. This is a good way to see the source code as reported. The lines are shown in a scrollable menu. This command is faster than 'Move Cursor| to report line' because it processes fewer reported lines. Script: cmGoToDescRepLine In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which report line will become the next current line. Move Cursor|to sibling F8 Selects one of the current line's siblings as the current line. This is a good way to see the sibling lines. The lines are shown in a scrollable menu. Each line begins with the line number that the text appears at. The text that follows the line number has the <^> characters replaced with the appropriate text. Script: cmGoToSibling In the script, EVOLVE! looks for the a number at the beginning of the instruction's first child to indicate which of the current line's siblings will become the next current line. If the number is 0 then the first sibling will become the current line. In general, if the number is N then the N+1 sibling will become the current line. Relocate|Line from clipboard Shift-F2 Takes a line from the clip board and inserts it in the current window. If the line has children, the line's parent will adopt them. If the clip board is not open yet, EVOLVE! will open it. Relocate|Line to clipboard Shift-F1 Cuts a line from the current window and inserts it in the clip board. If the line has children, the line's parent will adopt them. If the clip board is not open yet, EVOLVE! will open it. Relocate|Marked lines to under current Shift-F3 Relocates marked lines to under current. Script: cmMoveMarkedLines Relocate|Sort|Ascending Grey-Plus Sorts the siblings, under one branch, in ascending order. Script: cmOrderAscend Relocate|Sort|Descending Grey-Minus Sorts the siblings, under one branch, in descending order. Script: cmOrderDescend Relocate|Tree Down Ctrl-PgDn Moves the current subtree up or down by switching its position with the sibling below. Script: cmMoveTreeDn Relocate|Tree from clipboard Ctrl-F2 Removes the current subtree from the clip board and inserts it under the current line in the current window. Relocate|Tree left a level Ctrl-Left Moves the current line and all its descendants such that its grandparent becomes its new parent. Script: cmMoveTreeLeft Relocate|Tree right a level Ctrl-Right Moves the current line and all its descendants such that its nearest sibling above it becomes its new parent. Script: cmMoveTreeRight Relocate|Tree to clipboard Ctrl-F1 Removes a subtree from the current window and inserts it under the current line in the clip board. EVOLVE! opens the clip board if it needs to do so. Relocate|Tree up Ctrl-PgUp Moves the current subtree up or down by switching its position with the sibling above. Script: cmMoveTreeUp Window|Cascade windows Shift-F8 Stacks all file viewers on the desktop. Window|Close window Alt-F3 Closes the active window. You can also click the Close box in the upper right corner to close a window. Window|Next F6 Cycles forwards through the windows on the desktop. Window|Open Clipboard Opens a window for the clip board. Window|Previous Shift-F6 Cycles forwards through the windows on the desktop. Window|Size/Move window Ctrl-F5 Changes the size or position of the active window. ==== Size ==== If you press Shift while you use the arrow keys, you can change the size of the active window. Once you've adjusted its size or position, press Enter. If a window has a Resize corner, you can drag that corner to resize the window. ====== Move ====== When you choose Window≥Size/Move, the active window moves in response to the arrow keys. Once you've moved a window to where you want it, press Enter. You can also move a window by dragging its title bar with the mouse. Window|Tile Alt-Z Tiles all windows on the desktop. Window|Zoom F5 Resizes the active window to the maximum size. If the window is already zoomed, you can choose this command to restore it to its previous size. You can also double-click anywhere on the window's title bar (except where an icon appears) to zoom or unzoom the window. Menu items sorted by hotkey Menu Item HotKey ---------------------------------------- --------------- Edit|Add a line|as the first line Edit|Display|Select display style Move Cursor|to basis of current Window|Open Clipboard Marking|Reference marked lines Alt-= Edit|Copy|Current line to clipboard Alt-C Edit|Delete|Current line Alt-D Window|Close window Alt-F3 Edit|Display|Show children of current Alt-F8 Move Cursor|to descendant report line Alt-F9 Execute as script program Alt-F10 Move Cursor|Go to line # Alt-G Edit|Display|Hide children Alt-H Move Cursor|to marked Alt-J Edit|Copy|Tree to clipboard Alt-K Move Cursor|Search Alt-S Marking|Mark/Unmark current line Alt-Space Marking|Unmark all lines Alt-U File|Exit Alt-X Window|Tile Alt-Z Move Cursor|Last line Ctrl-End Edit|Add a line|As a child of current Ctrl-Enter Relocate|Tree to clipboard Ctrl-F1 Relocate|Tree from clipboard Ctrl-F2 Edit|Add a line|as a parent of current Ctrl-F3 Edit|Copy|Marked trees to clipboard Ctrl-F4 Window|Size/Move window Ctrl-F5 Marking|Mark if found Ctrl-F6 File|Report to file Ctrl-F7 File|Import ASCII file Ctrl-F8 Move cursor|to report line Ctrl-F9 Move cursor|First line Ctrl-Home Relocate|Tree left a level Ctrl-Left Relocate|Tree down Ctrl-PgDn Relocate|Tree up Ctrl-PgUp File|Print Ctrl-PrtSc Relocate|Tree right a level Ctrl-Right Move cursor|Down a line Down Edit|Add a line|As a sibling of current Enter Edit|Undo Esc File|Save F2 File|Open F3 Move cursor|To child F4 Window|Zoom F5 Window|Next F6 Move cursor|To parent F7 Move cursor|To sibling F8 File|Save As F9 Relocate|Sort|Descending Grey-Minus Relocate|Sort|Ascending Grey-Plus Move cursor|Down a screen PgDn Move cursor|Up a screen PgUp Edit|Delete|Current tree Shift-Delete Relocate|Line to clipboard Shift-F1 Relocate|Line from clipboard Shift-F2 Relocate|Marked lines to under current Shift-F3 Edit|Copy|Marked lines to clipboard Shift-F4 Window|Previous Shift-F6 File|Print to file Shift-F7 Window|Cascade windows Shift-F8 File|Change directory Shift-F9 Move cursor|Up a line Up License Agreement Richard H. Smith 7040 Wick Lane Derwood, MD 20855 (301) 977-4166 Please use copy, and distribute EVOLVE!. This program is distributed as Shareware. Definition of Shareware Shareware distribution gives users a chance to try software before buying it. If you try a Shareware program and continue using it, you are expected to register. Individual programs differ on details -- some request registration while others require it, some specify a maximum trial period. With registration, you get anything from the simple right to continue using the software to an updated program with printed manual. Copyright laws apply to both Shareware and commercial software, and the copyright holder retains all rights, with a few specific exceptions as stated below. Shareware authors are accomplished programmers, just like commercial authors, and the programs are of comparable quality. (In both cases, there are good programs and bad ones!) The main difference is in the method of distribution. The author specifically grants the right to copy and distribute the software, either to all and sundry or to a specific group. For example, some authors require written permission before a commercial disk vendor may copy their Shareware. Shareware is a distribution method, not a type of software. You should find software that suits your needs and pocketbook, whether it's commercial or Shareware. The Shareware system makes fitting your needs easier, because you can try before you buy. And because the overhead is low, prices are low also. Shareware has the ultimate money-back guarantee -- if you don't use the product, you don't pay for it. Disclaimer - Agreement Users of EVOLVE! must accept this disclaimer of warranty: "EVOLVE! is supplied as is. The author disclaims all warranties, expressed or implied, including, without limitation, the warranties of merchantability and of fitness for any purpose. The author assumes no liability for damages, direct or consequential, which may result from the use of EVOLVE!. EVOLVE! is a "shareware program" and is provided at no charge to the user for evaluation. Feel free to share it with your friends, but please do not give it away altered or as part of another system. The essence of "user-supported" software is to provide personal computer users with quality software without high prices, and yet to provide incentive for programmers to continue to develop new products. If you find this program useful and find that you are using EVOLVE! and continue to use EVOLVE! after a reasonable trial period, you must make a registration payment of $29.00 plus $5.00 shipping and handling to Software Smiths. The $29.00 registration fee will license one copy for use on any one computer at any one time. If you find value in EVOLVE! but can not afford the $29.00, you may obtain a low priority registration by sending me a letter telling me that you can not afford to pay the $29.00 fee now, but that you intend to pay it in the future when you can afford it. You must treat this software just like a book. An example is that this software may be used by any number of people and may be freely moved from one computer location to another, so long as there is no possibility of it being used at one location while it's being used at another. Just as a book cannot be read by two different persons at the same time. The $5.00 shipping and handling will pay for material Software Smiths will mail to you upon registration. Commercial users of EVOLVE! must register and pay for their copies of EVOLVE! within 30 days of first use or their license is withdrawn. Site-License arrangements may be made by contacting Software Smiths. Anyone distributing EVOLVE! for any kind of remuneration must first contact Software Smiths at the address at the beginning of this appendix for authorization. This authorization will be automatically granted to distributors recognized by the (ASP) as adhering to its guidelines for shareware distributors, and such distributors may begin offering EVOLVE! immediately (However Software Smiths must still be advised so that the distributor can be kept up-to-date with the latest version of EVOLVE!.). You are encouraged to pass a copy of EVOLVE! along to your friends for evaluation. Please encourage them to register their copy if they find that they can use it. All registered users will receive a copy of the latest version of the EVOLVE! system. Benefits of registering Software Smiths will provide the following 1. If you register as a user and pay $5.00 shipping and handling, Software Smiths will send you the next version of EVOLVE!. Your registration will apply to this version mailed directly to you. 2. The registered version of the software will not have a registration notice at the start up. 3. Software Smiths will send you a printed user's guide. 4. Software Smiths will notify you of any significant bugs found. 5. Software Smiths will extend to you the first opportunity to purchase related programs. We currently plan to develop versions for OS/2 and Microsoft Windows. 6. Software Smiths will incorporate your ideas and feedback into the continued development of their products. 7. You may call or write to Software Smiths about any problem you have with EVOLVE! and we will do our best to remedy the situation. How To Register To register, use a text editor to fill out the form in the file "REGISTER.DOC". This form is shown on the next page: Registration Form Mail to: Richard H. Smith Software Smiths 7040 Wick Lane Derwood, MD 20855-1963 Name: Address: City: State: Zip code: Product Name: Version: Release: What is your occupation? What do you use this software for? What do you like most about our software? What do you like least about our software? What do you like most about our documentation? What do you like least about our documentation? What is the hardware configuration off your computer? CPU: [] 8088 [] 80286 [] 80386 [] 80486 Size Hard Disk: Type of Modem: 3 1/2" Disk Drive [] 5 1/4" Disk Drive [] What type of software do you use? Operating System: Graphical user interface: Programming Languages: Where did you get our software from? Check one: [] I have enclosed a check that includes the $29.00 registration fee. [] I can not afford the $29.00 now, but I will pay it when I can. Check one: [] I have enclosed a check that includes the $5.00 shipping and handling fee. [] I do not want Software Smiths to mail me anything. ASP Ombudsman Statement This program is produced by a member of the Association of Shareware Professionals (ASP). ASP wants to make sure that the shareware principle works for you. If you are unable to resolve a shareware-related problem with an ASP member by contacting the member directly, ASP may be able to help. The ASP Ombudsman can help you resolve a dispute or problem with an ASP member, but does not provide technical support for members' products. Please write to the ASP Ombudsman at 545 Grover Road, Muskegon, MI 49442 or send a CompuServe message via CompuServe Mail to ASP Ombudsman 70007,3536. About the Author Richard H. Smith, 7040 Wick Lane, Derwood, MD 20855 (301) 977-4166 Objective: An opportunity to perform systems analysis, software engineering and training. Operating Systems: MS-DOS, UNIX, VMS. Languages: Pascal, Prolog, Oracle, SQL-Plus, SLAM-II Applications: Wordperfect, Lotus 123, Lotus Freelance, Corel Draw. Hardware: IBM-PC, Unisys, Vax. Professional Experience: February 1991 - Present: Self Employed. Developed "EVOLVE!" a structure editor that empowers programmers to implement source code changes more efficiently than a text editor. This structure editor can produce source code in any language. June 1988-February 1991: Research Analyst and Software Engineer, Analytic Services Inc. Systems Analyst, software engineer, and instructor for the following products: Integrated SCOPE-MARGI (ISM). Used structured analysis and structured design to integrate two decision support systems (SCOPE & MARGI). Designed and developed a new capability for ISM that uses an event driven, object oriented user interface. Material Handling Equipment Decision Support System (MHE-DSS). Used structured analysis and structured design to develop this program for calculating the performance of MHE, and the Air Forces requirements for MHE. I coded the MHE-DSS in Pascal. The knowledgebase in the MHE-DSS was derived from a simulation I coded in SLAM-II. Joint Service Research, Development and Acquisition Plan management information system. I coded this in Oracle and SQL-Plus on a Unisys 5000. Method for analyzing Reliability Goals and Investments (MARGI), a decision support system for calculating the benefits in combat capability from aircraft reliability improvements. Used structured analysis and structured design to develop. Written in Turbo Pascal and Turbo Prolog. October 1984-June 1988 Acquisition Program Manager, United States Air Force Tactical Reconnaissance System Program Office. Managed the development and acquisition of tactical reconnaissance systems. Education: B.S. Engineering Physics, 1984, University of Colorado at Boulder.